package com.zhj.helloframework.util;

import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;

/**
 * @Author: zhj
 * @Description:
 * @Date: 2021/9/29 10:44
 * @Version: 1.0
 */
@Slf4j
public class ClassUtil {

    public static final String FILE_PROTOCOL = "file";

    /**
     * 根据传入的包名，获得该包下及其子包下所有的类
     * @param packageName 包名
     * @return
     */
    public static Set<Class<?>> extractPackageClass(String packageName) {

        // 获取当前线程的类加载器
        ClassLoader classLoader = getClassLoader();
        // 通过类加载器获取到加载的资源
        // String replace(String regex,String replacement)：用新字符串replacement替换所有的正则模式匹配的串
        URL url = classLoader.getResource(packageName.replace(".", "/"));// URL格式：file:/文件在本机上的绝对路径
        // url = "file:/E:/IdeaProjects/helloFramework/target/classes/com/zhj/demo"
        if (url == null) {
            log.warn("unable to retrieve anything from package: " + packageName);
            return null;
        }

        // 依据不同的资源，采用不同的方式获取资源的集合
        Set<Class<?>> classSet = null;
        // 过滤出文件类型的资源
        if (url.getProtocol().equalsIgnoreCase(FILE_PROTOCOL)) {// 传输协议的判断
            classSet = new HashSet<>();
            File packageDirectory  = new File(url.getPath());
            extractClassFile(classSet, packageDirectory, packageName);
        }

        return classSet;
    }

    /**
     * 获取当前线程的上下文类加载器
     * @return 当前的类加载器
     */
    public static ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 将.class文件对应的Class对象放入emptyClassSet中
     * @param emptyClassSet 空的Set集合
     * @param fileSource 文件类型的资源
     * @param packageName 包名
     */
    private static void extractClassFile(Set<Class<?>> emptyClassSet, File fileSource, String packageName) {
        // 如果不是文件夹直接返回
        if (!fileSource.isDirectory()) {
            return;
        }
        // 如果是文件夹，那么将该文件夹下的.class文件对应的Class对象放入emptyClassSet中
        // listFile 只会返回该文件夹下的文件及文件夹，不会返回子文件夹下的内容，所以此处用listFiles
        File[] files = fileSource.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                // 如果File是目录，直接返回true，将该目录放入Files数组中递归
                if (pathname.isDirectory()) {
                    return true;
                } else {
                    // 如果不是文件夹，就把.class文件放入类集合中
                    String absoluteFilePath = pathname.getAbsolutePath();
                    if (absoluteFilePath.endsWith(".class")) {
                        addToClassSet(absoluteFilePath);
                    }
                }
                // 如果是文件类型，不需要放入Files数组，返回false
                return false;
            }

            // 加载.class文件，并生成Class对象放入ClassSet中
            private void addToClassSet(String absoluteFilePath) {
                // 从绝对路径下获取类名
                // 在 windows 中 File.separator 的作用相当于 '\'或'/'
                // 在 Linux 中，是不识别 ' \ '  的，而 File.separator 是系统默认的文件分隔符号，在 UNIX 系统上，此字段的值为 ' / '
                // absoluteFilePath = "E:\IdeaProjects\helloFramework\target\classes\com\zhj\demo\DemoTest.class"
                absoluteFilePath = absoluteFilePath.replace(File.separator,".");// 路径格式转换，转换后格式：file.packageName.className.class
                // absoluteFilePath = "E:.IdeaProjects.helloFramework.target.classes.com.zhj.demo.DemoTest.class"
                String className = absoluteFilePath.substring(absoluteFilePath.indexOf(packageName));// 转换后格式：packageName.className.class
                // className = "com.zhj.demo.DemoTest.class"
                className = className.substring(0,className.lastIndexOf("."));// 转换后格式：packageName.className
                // className = "com.zhj.demo.DemoTest"
                // 通过反射获取Class对象
                Class targetClass = loadClass(className);
                emptyClassSet.add(targetClass);
            }
        });

        // 递归剩余的子目录
        if (files != null) {
            for (File file : files) {
                extractClassFile(emptyClassSet, file, packageName);
            }
        }
    }

    /**
     * 通过反射获取Class对象
     * @param className .class文件对应的名字
     * @return Class对象
     */
    public static Class<?> loadClass(String className) {
        try {
            // 通过反射获取Class对象
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            log.error("load class error");
            throw new RuntimeException(e);
        }
    }

    /**
     * 通过反射来实例化对象
     * @param tClass 实例化对象
     * @param accessible 是否可以通过反射来访问该class的private修饰的构造函数
     * @param <T>
     * @return
     */
    public static <T> T newInstance(Class<T> tClass,boolean accessible) {
        try {
            // 获取我们需要的实例化对象的构造器对象
            Constructor constructor = tClass.getDeclaredConstructor();
            // 设置构造器对象的访问属性，当该对象为私有时，要传入accessible=true
            // 防止获取的是private类型的构造函数
            constructor.setAccessible(accessible);
            // 实例化对象并返回
            return (T) constructor.newInstance();
        } catch (Exception e) {
            log.error("newInstance error",e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 设置类的属性值
     * @param field 成员变量
     * @param target 类实例对象
     * @param value 成员变量的值
     * @param accessible 是否允许设置私有属性
     */
    public static void setField(Field field,Object target,Object value,boolean accessible) {
        // 设置该属性的访问参数，一般为true可以访问private类型的属性
        field.setAccessible(accessible);
        try {
            // 为field设置值
            field.set(target,value);
        } catch (IllegalAccessException e) {
            log.error("setField error", e);
            throw new RuntimeException(e);
        }
    }
}
